home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gxclread.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  16.3 KB  |  528 lines
  1. /* Copyright (C) 1991, 1996, 1997, 1998, 1999 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gxclread.c,v 1.2.2.1 2000/11/09 23:36:53 rayjj Exp $ */
  20. /* Command list reading for Ghostscript. */
  21. #include "memory_.h"
  22. #include "gx.h"
  23. #include "gp.h"            /* for gp_fmode_rb */
  24. #include "gpcheck.h"
  25. #include "gserrors.h"
  26. #include "gxdevice.h"
  27. #include "gscoord.h"        /* requires gsmatrix.h */
  28. #include "gsdevice.h"        /* for gs_deviceinitialmatrix */
  29. #include "gxdevmem.h"        /* must precede gxcldev.h */
  30. #include "gxcldev.h"
  31. #include "gxgetbit.h"
  32. #include "gxhttile.h"
  33. #include "gdevht.h"
  34. #include "gdevplnx.h"
  35. /*
  36.  * We really don't like the fact that gdevprn.h is included here, since
  37.  * command lists are supposed to be usable for purposes other than printer
  38.  * devices; but gdev_prn_colors_used and gdev_create_buf_device are
  39.  * currently only applicable to printer devices.
  40.  */
  41. #include "gdevprn.h"
  42. #include "stream.h"
  43. #include "strimpl.h"
  44.  
  45. /* ------ Band file reading stream ------ */
  46.  
  47. /*
  48.  * To separate banding per se from command list interpretation,
  49.  * we make the command list interpreter simply read from a stream.
  50.  * When we are actually doing banding, the stream filters the band file
  51.  * and only passes through the commands for the current bands (or band
  52.  * ranges that include a current band).
  53.  */
  54. typedef struct stream_band_read_state_s {
  55.     stream_state_common;
  56.     gx_band_page_info_t page_info;
  57.     int band_first, band_last;
  58.     uint left;            /* amount of data left in this run */
  59.     cmd_block b_this;
  60. } stream_band_read_state;
  61.  
  62. private int
  63. s_band_read_init(stream_state * st)
  64. {
  65.     stream_band_read_state *const ss = (stream_band_read_state *) st;
  66.  
  67.     ss->left = 0;
  68.     ss->b_this.band_min = 0;
  69.     ss->b_this.band_max = 0;
  70.     ss->b_this.pos = 0;
  71.     clist_rewind(ss->page_bfile, false, ss->page_bfname);
  72.     return 0;
  73. }
  74.  
  75. private int
  76. s_band_read_process(stream_state * st, stream_cursor_read * ignore_pr,
  77.             stream_cursor_write * pw, bool last)
  78. {
  79.     stream_band_read_state *const ss = (stream_band_read_state *) st;
  80.     register byte *q = pw->ptr;
  81.     byte *wlimit = pw->limit;
  82.     clist_file_ptr cfile = ss->page_cfile;
  83.     clist_file_ptr bfile = ss->page_bfile;
  84.     uint left = ss->left;
  85.     int status = 1;
  86.     uint count;
  87.  
  88.     while ((count = wlimit - q) != 0) {
  89.     if (left) {        /* Read more data for the current run. */
  90.         if (count > left)
  91.         count = left;
  92.         clist_fread_chars(q + 1, count, cfile);
  93.         if (clist_ferror_code(cfile) < 0) {
  94.         status = ERRC;
  95.         break;
  96.         }
  97.         q += count;
  98.         left -= count;
  99.         process_interrupts();
  100.         continue;
  101.     }
  102. rb:
  103.     /*
  104.      * Scan for the next run for the current bands (or a band range
  105.      * that includes a current band).
  106.      */
  107.     if (ss->b_this.band_min == cmd_band_end &&
  108.         clist_ftell(bfile) == ss->page_bfile_end_pos
  109.         ) {
  110.         status = EOFC;
  111.         break;
  112.     } {
  113.         int bmin = ss->b_this.band_min;
  114.         int bmax = ss->b_this.band_max;
  115.         long pos = ss->b_this.pos;
  116.  
  117.         clist_fread_chars(&ss->b_this, sizeof(ss->b_this), bfile);
  118.         if (!(ss->band_last >= bmin && ss->band_first <= bmax))
  119.         goto rb;
  120.         clist_fseek(cfile, pos, SEEK_SET, ss->page_cfname);
  121.         left = (uint) (ss->b_this.pos - pos);
  122.         if_debug5('l', "[l]reading for bands (%d,%d) at bfile %ld, cfile %ld, length %u\n",
  123.               bmin, bmax,
  124.               clist_ftell(bfile) - 2 * sizeof(ss->b_this),
  125.               pos, left);
  126.     }
  127.     }
  128.     pw->ptr = q;
  129.     ss->left = left;
  130.     return status;
  131. }
  132.  
  133. /* Stream template */
  134. private const stream_template s_band_read_template = {
  135.     &st_stream_state, s_band_read_init, s_band_read_process, 1, cbuf_size
  136. };
  137.  
  138.  
  139. /* ------ Reading/rendering ------ */
  140.  
  141. /* Forward references */
  142.  
  143. private int clist_render_init(P1(gx_device_clist *));
  144. private int clist_playback_file_bands(P8(clist_playback_action action,
  145.                      gx_device_clist_reader *cdev,
  146.                      gx_band_page_info_t *page_info,
  147.                      gx_device *target,
  148.                      int band_first, int band_last,
  149.                      int x0, int y0));
  150. private int clist_rasterize_lines(P6(gx_device *dev, int y, int lineCount,
  151.                      gx_device *bdev,
  152.                      const gx_render_plane_t *render_plane,
  153.                      int *pmy));
  154.  
  155. /* Calculate the raster for a chunky or planar device. */
  156. private int
  157. clist_plane_raster(const gx_device *dev, const gx_render_plane_t *render_plane)
  158. {
  159.     return bitmap_raster(dev->width *
  160.              (render_plane && render_plane->index >= 0 ?
  161.               render_plane->depth : dev->color_info.depth));
  162. }
  163.  
  164. /* Select full-pixel rendering if required for RasterOp. */
  165. private void
  166. clist_select_render_plane(gx_device *dev, int y, int height,
  167.               gx_render_plane_t *render_plane, int index)
  168. {
  169.     if (index >= 0) {
  170.     gx_colors_used_t colors_used;
  171.     int ignore_start;
  172.  
  173.     gdev_prn_colors_used(dev, y, height, &colors_used,  &ignore_start);
  174.     if (colors_used.slow_rop)
  175.         index = -1;
  176.     }
  177.     if (index < 0)
  178.     render_plane->index = index;
  179.     else
  180.     gx_render_plane_init(render_plane, dev, index);
  181. }
  182.  
  183. /*
  184.  * Do device setup from params stored in command list. This is only for
  185.  * async rendering & assumes that the first command in every command list
  186.  * is a put_params command which sets all space-related parameters to the
  187.  * value they will have for the duration of that command list.
  188.  */
  189. int
  190. clist_setup_params(gx_device *dev)
  191. {
  192.     gx_device_clist_reader * const crdev =
  193.     &((gx_device_clist *)dev)->reader;
  194.     int code = clist_render_init((gx_device_clist *)dev);
  195.     if (code < 0)
  196.     return code;
  197.  
  198.     code = clist_playback_file_bands(playback_action_setup,
  199.                      crdev, &crdev->page_info, 0, 0, 0, 0, 0);
  200.  
  201.     /* put_params may have reinitialized device into a writer */
  202.     clist_render_init((gx_device_clist *)dev);
  203.  
  204.     return code;
  205. }
  206.  
  207. /* Copy a rasterized rectangle to the client, rasterizing if needed. */
  208. int
  209. clist_get_bits_rectangle(gx_device *dev, const gs_int_rect * prect,
  210.              gs_get_bits_params_t *params, gs_int_rect **unread)
  211. {
  212.     gx_device_clist_common *cdev = (gx_device_clist_common *)dev;
  213.     gs_get_bits_options_t options = params->options;
  214.     int y = prect->p.y;
  215.     int end_y = prect->q.y;
  216.     int line_count = end_y - y;
  217.     gs_int_rect band_rect;
  218.     int lines_rasterized;
  219.     gx_device *bdev;
  220.     int num_planes =
  221.     (options & GB_PACKING_CHUNKY ? 1 :
  222.      options & GB_PACKING_PLANAR ? dev->color_info.num_components :
  223.      options & GB_PACKING_BIT_PLANAR ? dev->color_info.depth :
  224.      0 /****** NOT POSSIBLE ******/);
  225.     gx_render_plane_t render_plane;
  226.     int plane_index;
  227.     int my;
  228.     int code;
  229.  
  230.     if (prect->p.x < 0 || prect->q.x > dev->width ||
  231.     y < 0 || end_y > dev->height
  232.     )
  233.     return_error(gs_error_rangecheck);
  234.     if (line_count <= 0 || prect->p.x >= prect->q.x)
  235.     return 0;
  236.  
  237.     /*
  238.      * Calculate the render_plane from the params.  There are two cases:
  239.      * full pixels, or a single plane.
  240.      */
  241.     plane_index = -1;
  242.     if (options & GB_SELECT_PLANES) {
  243.     /* Look for the one selected plane. */
  244.     int i;
  245.  
  246.     for (i = 0; i < num_planes; ++i)
  247.         if (params->data[i]) {
  248.         if (plane_index >= 0)  /* >1 plane requested */
  249.             return gx_default_get_bits_rectangle(dev, prect, params,
  250.                              unread);
  251.         plane_index = i;
  252.         }
  253.     }
  254.     clist_select_render_plane(dev, y, line_count, &render_plane, plane_index);
  255.     code = gdev_create_buf_device(cdev->buf_procs.create_buf_device,
  256.                   &bdev, cdev->target, &render_plane,
  257.                   dev->memory, true);
  258.     if (code < 0)
  259.     return code;
  260.     code = clist_rasterize_lines(dev, y, line_count, bdev, &render_plane, &my);
  261.     if (code < 0)
  262.     return code;
  263.     lines_rasterized = min(code, line_count);
  264.     /* Return as much of the rectangle as falls within the rasterized lines. */
  265.     band_rect = *prect;
  266.     band_rect.p.y = my;
  267.     band_rect.q.y = my + lines_rasterized;
  268.     code = dev_proc(bdev, get_bits_rectangle)
  269.     (bdev, &band_rect, params, unread);
  270.     cdev->buf_procs.destroy_buf_device(bdev);
  271.     if (code < 0 || lines_rasterized == line_count)
  272.     return code;
  273.     /*
  274.      * We'll have to return the rectangle in pieces.  Force GB_RETURN_COPY
  275.      * rather than GB_RETURN_POINTER, and require all subsequent pieces to
  276.      * use the same values as the first piece for all of the other format
  277.      * options.  If copying isn't allowed, or if there are any unread
  278.      * rectangles, punt.
  279.      */
  280.     if (!(options & GB_RETURN_COPY) || code > 0)
  281.     return gx_default_get_bits_rectangle(dev, prect, params, unread);
  282.     options = params->options;
  283.     if (!(options & GB_RETURN_COPY)) {
  284.     /* Redo the first piece with copying. */
  285.     params->options = options =
  286.         (params->options & ~GB_RETURN_ALL) | GB_RETURN_COPY;
  287.     lines_rasterized = 0;
  288.     }
  289.     {
  290.     gs_get_bits_params_t band_params;
  291.     uint raster = gx_device_raster(bdev, true);
  292.  
  293.     code = gdev_create_buf_device(cdev->buf_procs.create_buf_device,
  294.                       &bdev, cdev->target, &render_plane,
  295.                       dev->memory, true);
  296.     if (code < 0)
  297.         return code;
  298.     band_params = *params;
  299.     while ((y += lines_rasterized) < end_y) {
  300.         int i;
  301.  
  302.         /* Increment data pointers by lines_rasterized. */
  303.         for (i = 0; i < num_planes; ++i)
  304.         if (band_params.data[i])
  305.             band_params.data[i] += raster * lines_rasterized;
  306.         line_count = end_y - y;
  307.         code = clist_rasterize_lines(dev, y, line_count, bdev,
  308.                      &render_plane, &my);
  309.         if (code < 0)
  310.         break;
  311.         lines_rasterized = min(code, line_count);
  312.         band_rect.p.y = my;
  313.         band_rect.q.y = my + lines_rasterized;
  314.         code = dev_proc(bdev, get_bits_rectangle)
  315.         (bdev, &band_rect, &band_params, unread);
  316.         if (code < 0)
  317.         break;
  318.         params->options = options = band_params.options;
  319.         if (lines_rasterized == line_count)
  320.         break;
  321.     }
  322.     cdev->buf_procs.destroy_buf_device(bdev);
  323.     }
  324.     return code;
  325. }
  326.  
  327. /* Copy scan lines to the client.  This is where rendering gets done. */
  328. /* Processes min(requested # lines, # lines available thru end of band) */
  329. private int    /* returns -ve error code, or # scan lines copied */
  330. clist_rasterize_lines(gx_device *dev, int y, int line_count,
  331.               gx_device *bdev, const gx_render_plane_t *render_plane,
  332.               int *pmy)
  333. {
  334.     gx_device_clist * const cdev = (gx_device_clist *)dev;
  335.     gx_device_clist_reader * const crdev = &cdev->reader;
  336.     gx_device *target = crdev->target;
  337.     uint raster = clist_plane_raster(target, render_plane);
  338.     byte *mdata = crdev->data + crdev->page_tile_cache_size;
  339.     int plane_index = (render_plane ? render_plane->index : -1);
  340.     int code;
  341.  
  342.     /* Render a band if necessary, and copy it incrementally. */
  343.     if (crdev->ymin < 0 || crdev->yplane.index != plane_index ||
  344.     !(y >= crdev->ymin && y < crdev->ymax)
  345.     ) {
  346.     int band_height = crdev->page_band_height;
  347.     int band = y / band_height;
  348.     int band_begin_line = band * band_height;
  349.     int band_end_line = band_begin_line + band_height;
  350.     int band_num_lines;
  351.     gs_int_rect band_rect;
  352.  
  353.     if (band_end_line > dev->height)
  354.         band_end_line = dev->height;
  355.     /* Clip line_count to current band */
  356.     if (line_count > band_end_line - y)
  357.         line_count = band_end_line - y;
  358.     band_num_lines = band_end_line - band_begin_line;
  359.  
  360.     if (y < 0 || y > dev->height)
  361.         return_error(gs_error_rangecheck);
  362.     code = crdev->buf_procs.setup_buf_device
  363.         (bdev, mdata, raster, NULL, 0, band_num_lines, band_num_lines);
  364.     band_rect.p.x = 0;
  365.     band_rect.p.y = band_begin_line;
  366.     band_rect.q.x = dev->width;
  367.     band_rect.q.y = band_end_line;
  368.     if (code >= 0)
  369.         code = clist_render_rectangle(cdev, &band_rect, bdev, render_plane,
  370.                       true);
  371.     /* Reset the band boundaries now, so that we don't get */
  372.     /* an infinite loop. */
  373.     crdev->ymin = band_begin_line;
  374.     crdev->ymax = band_end_line;
  375.     if (code < 0)
  376.         return code;
  377.     }
  378.  
  379.     if (line_count > crdev->ymax - y)
  380.     line_count = crdev->ymax - y;
  381.     code = crdev->buf_procs.setup_buf_device
  382.     (bdev, mdata, raster, NULL, y - crdev->ymin, line_count,
  383.      crdev->ymax - crdev->ymin);
  384.     if (code < 0)
  385.     return code;
  386.  
  387.     *pmy = 0;
  388.     return line_count;
  389. }
  390.  
  391. /* Initialize for reading. */
  392. private int
  393. clist_render_init(gx_device_clist *dev)
  394. {
  395.     gx_device_clist_reader * const crdev = &dev->reader;
  396.  
  397.     crdev->ymin = crdev->ymax = 0;
  398.     crdev->yplane.index = -1;
  399.     /* For normal rasterizing, pages and num_pages are zero. */
  400.     crdev->pages = 0;
  401.     crdev->num_pages = 0;
  402.     return 0;
  403. }
  404.  
  405. /*
  406.  * Render a rectangle to a client-supplied device.  There is no necessary
  407.  * relationship between band boundaries and the region being rendered.
  408.  */
  409. int
  410. clist_render_rectangle(gx_device_clist *cdev, const gs_int_rect *prect,
  411.                gx_device *bdev,
  412.                const gx_render_plane_t *render_plane, bool clear)
  413. {
  414.     gx_device_clist_reader * const crdev = &cdev->reader;
  415.     const gx_placed_page *ppages;
  416.     int num_pages = crdev->num_pages;
  417.     int band_height = crdev->page_band_height;
  418.     int band_first = prect->p.y / band_height;
  419.     int band_last = (prect->q.y - 1) / band_height;
  420.     gx_saved_page current_page;
  421.     gx_placed_page placed_page;
  422.     int code = 0;
  423.     int i;
  424.  
  425.     /* Initialize for rendering if we haven't done so yet. */
  426.     if (crdev->ymin < 0) {
  427.     code = clist_end_page(&cdev->writer);
  428.     if (code < 0)
  429.         return code;
  430.     code = clist_render_init(cdev);
  431.     if (code < 0)
  432.         return code;
  433.     }
  434.     if (render_plane)
  435.     crdev->yplane = *render_plane;
  436.     else
  437.     crdev->yplane.index = -1;
  438.     if_debug2('l', "[l]rendering bands (%d,%d)\n", band_first, band_last);
  439.     if (clear)
  440.     dev_proc(bdev, fill_rectangle)
  441.         (bdev, 0, 0, bdev->width, bdev->height, gx_device_white(bdev));
  442.  
  443.     /*
  444.      * If we aren't rendering saved pages, do the current one.
  445.      * Note that this is the only case in which we may encounter
  446.      * a gx_saved_page with non-zero cfile or bfile.
  447.      */
  448.     ppages = crdev->pages;
  449.     if (ppages == 0) {
  450.     current_page.info = crdev->page_info;
  451.     placed_page.page = ¤t_page;
  452.     placed_page.offset.x = placed_page.offset.y = 0;
  453.     ppages = &placed_page;
  454.     num_pages = 1;
  455.     }
  456.     for (i = 0; i < num_pages && code >= 0; ++i) {
  457.     const gx_placed_page *ppage = &ppages[i];
  458.  
  459.     code = clist_playback_file_bands(playback_action_render,
  460.                      crdev, &ppage->page->info,
  461.                      bdev, band_first, band_last,
  462.                      prect->p.x - ppage->offset.x,
  463.                      prect->p.y);
  464.     }
  465.     return code;
  466. }
  467.  
  468. /* Playback the band file, taking the indicated action w/ its contents. */
  469. private int
  470. clist_playback_file_bands(clist_playback_action action, 
  471.               gx_device_clist_reader *cdev,
  472.               gx_band_page_info_t *page_info, gx_device *target,
  473.               int band_first, int band_last, int x0, int y0)
  474. {
  475.     int code = 0;
  476.     bool opened_bfile = false;
  477.     bool opened_cfile = false;
  478.  
  479.     /* We have to pick some allocator for rendering.... */
  480.     gs_memory_t *mem =
  481.     (cdev->memory != 0 ? cdev->memory : &gs_memory_default);
  482.  
  483.     stream_band_read_state rs;
  484.  
  485.     /* setup stream */
  486.     s_init_state((stream_state *)&rs, &s_band_read_template,
  487.          (gs_memory_t *)0);
  488.     rs.band_first = band_first;
  489.     rs.band_last = band_last;
  490.     rs.page_info = *page_info;
  491.  
  492.     /* If this is a saved page, open the files. */
  493.     if (rs.page_cfile == 0) {
  494.     code = clist_fopen(rs.page_cfname,
  495.                gp_fmode_rb, &rs.page_cfile, cdev->bandlist_memory,
  496.                cdev->bandlist_memory, true);
  497.     opened_cfile = (code >= 0);
  498.     }
  499.     if (rs.page_bfile == 0 && code >= 0) {
  500.     code = clist_fopen(rs.page_bfname,
  501.                gp_fmode_rb, &rs.page_bfile, cdev->bandlist_memory,
  502.                cdev->bandlist_memory, false);
  503.     opened_bfile = (code >= 0);
  504.     }
  505.     if (rs.page_cfile != 0 && rs.page_bfile != 0) {
  506.     stream s;
  507.     byte sbuf[cbuf_size];
  508.     static const stream_procs no_procs = {
  509.         s_std_noavailable, s_std_noseek, s_std_read_reset,
  510.         s_std_read_flush, s_std_close, s_band_read_process
  511.     };
  512.  
  513.     s_band_read_init((stream_state *)&rs);
  514.     s_std_init(&s, sbuf, cbuf_size, &no_procs, s_mode_read);
  515.     s.foreign = 1;
  516.     s.state = (stream_state *)&rs;
  517.     code = clist_playback_band(action, cdev, &s, target, x0, y0, mem);
  518.     }
  519.  
  520.     /* Close the files if we just opened them. */
  521.     if (opened_bfile && rs.page_bfile != 0)
  522.     clist_fclose(rs.page_bfile, rs.page_bfname, false);
  523.     if (opened_cfile && rs.page_cfile != 0)
  524.     clist_fclose(rs.page_cfile, rs.page_cfname, false);
  525.  
  526.     return code;
  527. }
  528.